Bytecode Closures

This article describes a new project to study the memory performance of three new implementation strategies for closures coined bytecode closures. The project proposes to compare the new implementation strategies to the classical strategy that dynamically allocates flat closures as heap data structures. The new closure representations are based on dynamically creating specialized bytecode instead of allocating a data structure. The first new strategy creates specialized functions by inlining the bindings of free variables. The second uses memoization to reduce the number of dynamically created functions. The third dynamically creates memoized specialized functions that treat free variables like parameters at runtime. Empirical results from a preliminary case-study using three small benchmarks are presented as a proof-of-concept. The data suggests that dynamically created bytecode closures in conjunction with memoization can allocate significantly less memory, as much as three orders of magnitude less memory in the presented benchmarks, than a flat closure implementation. Furthermore, the empirical data suggests that the size of a dynamically generated function ought to be proportional to the size of a flat closure. The article ends with other, longer term, interesting lines of research that are also pursued by this new project.